{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 前言\n",
    "\n",
    "聪明钱因子模型的核心逻辑是，从分钟行情数据的价量信息中，尝试识别机构参与交易的多寡，最终构造出一个跟踪聪明钱的选股因子。聪明钱因子的优点：一，模型逻辑简洁，样本内表现良好；其二，模型首次提出了“高频数据，低频因子”的研究模式，是高频因子领域的引领之作。\n",
    "\n",
    "聪明钱因子模型的核心问题是，如何识别聪明钱的交易。大量的实证研究表明， 聪明钱在交易过程中往往呈现“单笔订单数量更大、订单报价更为激进”的基本特征。基于这个考虑，我们构造了用于度量交易聪明度的指标S（表 1，步骤 2），指标S的数值越大，则认为该分钟的交易中有越多聪明钱参与。借助指标S，我们通过以下方法筛选聪明钱的交易：对于特定股票、特定时段的所有分钟行情数据，将其按照指标S从大到小进行排序，将成交量累积占比前 20%视为聪明钱的交易(表1,步骤3)。\n",
    "\n",
    "|步骤|说明|\n",
    "|--|--|\n",
    "|步骤1|对选定股票，回溯取其过去 10 个交易日的分钟行情数据；|\n",
    "|步骤2|构造指标$S_t = |R_t|/\\sqrt{V_t}$，其中𝑅𝑡为第t分钟涨跌幅，𝑉𝑡为第t分钟成交量；|\n",
    "|步骤3|将分钟数据按照指标St从大到小进行排序，取成交量累积占比前20%的分钟， 视为聪明钱交易；|\n",
    "|步骤4|计算聪明钱交易的成交量加权平均价$VWAP_{smart}$；|\n",
    "|步骤5|计算所有交易的成交量加权平均价$VWAP_{all}$；|\n",
    "|步骤6|聪明钱因子Q = $VWAP_{smart}/VWAP_{all}$。|\n",
    "\n",
    "为了更形象地展示这个划分过程，图1中我们给出了一个简单示例。图1的上半部分：这是一段长度为*半小时*的分钟行情数据，按照时间顺序排列，时间标签依次标为 1-30，蓝柱代表每分钟的成交量，红点代表每分钟的S指标值。图1的下半部分：我们按照S值从大到小对原始行情数据进行了重新排序，柱子仍代表每分钟的成交量，绿线代表成交量从左到右的累计占比（相对于总成交量）；以成交量累计占比20%作为划分的界线，将最左侧的6个分钟数据（红柱）划归为聪明钱的交易，剩余的其他分钟数据（蓝柱）则被划为普通资金的交易。\n",
    "\n",
    "![avatar]()\n",
    "\n",
    "从\"量-价\"相空间的视角，我们可以更直观地感受S指标在划分过程中起到的作用。在图2中，横坐标为分钟成交量V，纵坐标为分钟涨跌幅的绝对值|R|，每个散点代表一个分钟交易。在最终的划分结果中，红色散点为聪明钱交易，蓝色散点为普通交易，虚线为划分两种交易的分界线。不难发现，分界线的形状直接取决于S指标的构造方式——假设成交量累积占比恰好为20%的分钟交易的S指标值为S0， 则分界线表达式为$|R| = S_0\\sqrt{V}$。不同的 S 指标的构造方式，将产生不同的聪明钱划分结果。\n",
    "\n",
    "![avatar]()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. 引入所需的库**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# 引入库\n",
    "import sys\n",
    "sys.path.append('../../..')\n",
    "\n",
    "from BuildPeriodDate import (GetTradePeriod,tdaysoffset)\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import empyrical as ep\n",
    "import alphalens as al\n",
    "import scipy.stats as st\n",
    "import alphalens.performance as perf\n",
    "from alphalens.utils import print_table\n",
    "\n",
    "from jqdata import *\n",
    "from jqfactor import (Factor,calc_factors)\n",
    "\n",
    "import itertools\n",
    "from typing import (Tuple,List,Dict,Union,Callable)\n",
    "from functools import reduce\n",
    "from tqdm import tqdm_notebook\n",
    "from dateutil.parser import parse\n",
    "\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "mpl.rcParams['font.family']='serif' # pd.plot中文\n",
    "# 用来正常显示负号\n",
    "mpl.rcParams['axes.unicode_minus'] = False\n",
    "# 图表主题\n",
    "plt.style.use('seaborn')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.股票池过滤**\n",
    "\n",
    "1. 过滤上述不足60日的次新;\n",
    "2. 过滤停牌10日的股票\n",
    "3. 过滤ST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     1,
     15,
     23,
     29
    ]
   },
   "outputs": [],
   "source": [
    "# 获取股票池\n",
    "def get_stockpool(symbol: str, watch_date: str) -> list:\n",
    "    '''获取股票池'''\n",
    "\n",
    "    if symbol == 'A':\n",
    "        stockList = get_index_stocks('000001.XSHG', date=watch_date) + get_index_stocks(\n",
    "            '399107.XSHE', date=watch_date)\n",
    "    else:\n",
    "        stockList = get_index_stocks(symbol, date=watch_date)\n",
    "        \n",
    "    stockList = del_st_stock(stockList, watch_date)  # 过滤ST\n",
    "    stockList = del_iponday(stockList, watch_date)   # 过滤上市不足60日\n",
    "    stockList = del_pause(stockList,watch_date)      # 过滤当日停牌的股票\n",
    "    return stockList\n",
    "\n",
    "def del_st_stock(securities: list, watch_date: str) -> list:\n",
    "    '''过滤ST股票'''\n",
    "\n",
    "    info_ser = get_extras('is_st', securities,\n",
    "                          end_date=watch_date, df=True, count=1).iloc[0]\n",
    "\n",
    "    return info_ser[info_ser == False].dropna().index.tolist()\n",
    "\n",
    "def del_iponday(securities: list, watch_date: str, N: int = 60) -> list:\n",
    "    '''返回上市大于N日的股票'''\n",
    "    dic = {x: get_security_info(x, date=watch_date).start_date for x in securities if get_security_info(\n",
    "        x, date=watch_date) != None}\n",
    "    return [code for code, start_date in dic.items() if (parse(watch_date).date() - start_date).days > N]\n",
    "\n",
    "def del_pause(securities:list,watch_date:str,N:int=10)->list:\n",
    "    \n",
    "    '''\n",
    "    过滤停牌股,默认为过滤当日停牌的\n",
    "    '''\n",
    "    \n",
    "    paused = get_price(securities,end_date=watch_date,count=N,fields='paused',panel=False)\n",
    "    \n",
    "    if N == 1:\n",
    "        return paused.query('paused != 1')['code'].values.tolist()\n",
    "    else:\n",
    "        \n",
    "        paused_num = paused.groupby('code')['paused'].sum()\n",
    "        return paused_num[paused_num < N].index.values.tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. 因子获取**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [
     1,
     49
    ]
   },
   "outputs": [],
   "source": [
    "# 因子计算\n",
    "def prepare_data(symbol: str, start: str, end: str, last_date: str, \n",
    "                 factor: Callable, grid_func_params: Dict,mod='normal') -> pd.DataFrame:\n",
    "    '''\n",
    "    symbol:股票池所属成份，A为全市场\n",
    "    start,end:回测区间 频率为月度\n",
    "    last_date:计算next_returns的最后一日的日期\n",
    "    factor:构建的因子\n",
    "    '''\n",
    "    periods = GetTradePeriod(start, end, 'ME')  # 月度_周期获取\n",
    "    periods = periods + [last_date]\n",
    "    factor_dic = {}\n",
    "\n",
    "    for tradeDate, nextDate in tqdm_notebook(zip(periods[:-1], periods[1:]), total=len(periods)-1, desc='因子计算'):\n",
    "\n",
    "        # 股票池\n",
    "        stock_pool = get_stockpool(symbol, tradeDate.strftime('%Y-%m-%d'))\n",
    "\n",
    "        # 因子获取\n",
    "\n",
    "        f = factor(securities=stock_pool, watch_date=tradeDate,mod=mod)\n",
    "        \n",
    "        # 获取数据 这里仅需获取一次就能使用该数据进行N此不同参数运算\n",
    "        f.get_data() \n",
    "        # 可以使用不同参数进行计算\n",
    "        factor_frame = grid_func_params['func'](\n",
    "            f, **grid_func_params['params'])\n",
    "\n",
    "        # 计算下期收益率\n",
    "        close = get_price(stock_pool, end_date=tradeDate, count=1,\n",
    "                          fields='close', panel=False).set_index('code')\n",
    "\n",
    "        next_close = get_price(stock_pool, end_date=nextDate,\n",
    "                               count=1, fields='close', panel=False).set_index('code')\n",
    "\n",
    "        next_returns = next_close['close'] / close['close'] - 1\n",
    "        next_returns.name = 'next_ret'\n",
    "\n",
    "        # 合并\n",
    "        tmp = pd.concat((factor_frame, next_returns), axis=1,sort=True)\n",
    "        factor_dic[tradeDate] = tmp  # 放入容器\n",
    "\n",
    "    factor_df = pd.concat(factor_dic,sort=True)\n",
    "\n",
    "    factor_df.index.names = ['date', 'code']\n",
    "\n",
    "    return factor_df\n",
    "\n",
    "\n",
    "def dict2frame(dic: dict) -> pd.DataFrame:\n",
    "    '''将data的dict格式转为df'''\n",
    "\n",
    "    df = pd.concat((df.iloc[-1] for df in dic.values()), axis=1)\n",
    "    df.columns = list(dic.keys())\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. 工具类**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [
     1,
     12,
     18,
     31,
     42,
     58,
     91
    ]
   },
   "outputs": [],
   "source": [
    "# 计算ic\n",
    "def src_ic(df:pd.DataFrame)->pd.DataFrame:\n",
    "    \n",
    "    '''计算IC'''\n",
    "    \n",
    "    f = [col for col in df.columns if col != 'next_ret']\n",
    "    \n",
    "    _ic = df[f].apply(lambda x:st.spearmanr(x,df['next_ret'])[0])\n",
    "    \n",
    "    return _ic\n",
    "\n",
    "# 获取分组\n",
    "def add_group(ser: pd.Series, N: int = 5) -> pd.Series:\n",
    "\n",
    "    name = ['G%s' % x for x in range(1, N+1)]\n",
    "    return pd.qcut(ser, N, labels=name,duplicates='drop')\n",
    "\n",
    "# 获取分组收益率\n",
    "def get_algorithm_ret(factor_df: pd.DataFrame, col: str) -> pd.DataFrame:\n",
    "\n",
    "    group_ser = factor_df.groupby(level='date')[col].apply(add_group)\n",
    "    group_df = pd.concat((factor_df['next_ret'], group_ser), axis=1)\n",
    "\n",
    "    group_ret = pd.pivot_table(group_df.reset_index(\n",
    "    ), index='date', columns=col, values='next_ret')\n",
    "    group_ret.columns = list(map(str, group_ret.columns))\n",
    "    group_ret['excess_ret'] = group_ret['G1'] - group_ret['G5']\n",
    "\n",
    "    return group_ret\n",
    "\n",
    "# 获取多空收益\n",
    "def get_excess_ret(factor_df: pd.DataFrame, col: list) -> pd.DataFrame:\n",
    "\n",
    "    if isinstance(col, (str, float, int)):\n",
    "        col = [col]\n",
    "\n",
    "    df = pd.concat((get_algorithm_ret(factor_df, x)[\n",
    "                   'excess_ret'] for x in col), axis=1)\n",
    "    df.columns = col\n",
    "    return df\n",
    "\n",
    "# 风险指标\n",
    "def risk_indicator_tear(returns:pd.DataFrame,period:str='monthly')->pd.DataFrame:\n",
    "    \n",
    "    tear = pd.DataFrame()\n",
    "    tear['annual_return'] = ep.annual_return(returns,period)\n",
    "    tear['annual_volatility'] = returns.apply(lambda x:ep.annual_volatility(x,period))\n",
    "    tear['max_drawdown'] = returns.apply(lambda x:ep.max_drawdown(x))\n",
    "    \n",
    "    if 'benchmark' in returns.columns:\n",
    "        \n",
    "        select_col = [col for col in returns.columns if col != 'benchmark']\n",
    "\n",
    "        tear['IR'] = returns[select_col].apply(\n",
    "            lambda x: information_ratio(x, returns['benchmark']))\n",
    "    \n",
    "    return tear\n",
    "\n",
    "def information_ratio(returns, factor_returns):\n",
    "    \"\"\"\n",
    "    Determines the Information ratio of a strategy.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    returns : :py:class:`pandas.Series` or pd.DataFrame\n",
    "        Daily returns of the strategy, noncumulative.\n",
    "        See full explanation in :func:`~empyrical.stats.cum_returns`.\n",
    "    factor_returns: :class:`float` / :py:class:`pandas.Series`\n",
    "        Benchmark return to compare returns against.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    :class:`float`\n",
    "        The information ratio.\n",
    "\n",
    "    Note\n",
    "    -----\n",
    "    See https://en.wikipedia.org/wiki/information_ratio for more details.\n",
    "\n",
    "    \"\"\"\n",
    "    if len(returns) < 2:\n",
    "        return np.nan\n",
    "\n",
    "    active_return = _adjust_returns(returns, factor_returns)\n",
    "    tracking_error = np.std(active_return, ddof=1)\n",
    "    if np.isnan(tracking_error):\n",
    "        return 0.0\n",
    "    if tracking_error == 0:\n",
    "        return np.nan\n",
    "    return np.mean(active_return) / tracking_error\n",
    "\n",
    "def _adjust_returns(returns, adjustment_factor):\n",
    "    \"\"\"\n",
    "    Returns a new :py:class:`pandas.Series` adjusted by adjustment_factor.\n",
    "    Optimizes for the case of adjustment_factor being 0.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    returns : :py:class:`pandas.Series`\n",
    "    adjustment_factor : :py:class:`pandas.Series` / :class:`float`\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    :py:class:`pandas.Series`\n",
    "    \"\"\"\n",
    "    if isinstance(adjustment_factor, (float, int)) and adjustment_factor == 0:\n",
    "        return returns.copy()\n",
    "    return returns - adjustment_factor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. 因子构建**\n",
    "\n",
    "**对开跟号的修正 这算是对初始聪明钱因子的改进方案**\n",
    "\n",
    "在聪明钱因子的构造步骤中，S指标的计算公式为$S = |R|/\\sqrt{V}$，分母为分钟成交量V的开根号。我们选择开根号的初衷是：（1）开根号有简单清晰的数学图像可对 应；（2）大量的实证研究表明，价格变化与成交量的平方根之间存在正比关系。\n",
    "为了方便讨论，我们不妨尝试一般化，将分钟成交量V的指数项定义为可变的\n",
    "参数，这样 S 指标公式可以写成如下形式：$S = |R|/(V^\\beta)$其中，R为分钟涨跌幅，V 为分钟成交量，β为分钟成交量V的指数项参数。\n",
    "不难看出，当β取值为0.5时即为原始聪明钱因子S指标；当β取值为0时，S指标\n",
    "可以写为 S=|R|；当β取值为-0.5 时，S指标可以写为$S = |R| ∗ \\sqrt{V}$的乘积形式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "code_folding": [
     1,
     125
    ]
   },
   "outputs": [],
   "source": [
    "# 聪明钱因子\n",
    "class Q_factor(object):\n",
    "\n",
    "    def __init__(self, securities: Union[str, list], watch_date: str, N: int = 10, frequency: str = '30m',mod:str='normal') -> None:\n",
    "\n",
    "        self.securities = securities\n",
    "        self.watch_date = watch_date\n",
    "        self.frequency = frequency\n",
    "        self.N = N\n",
    "        self._get_count()\n",
    "        self.mod = mod # normal传统 ln对数\n",
    "\n",
    "    def get_data(self):\n",
    "\n",
    "        self.data = get_price(self.securities,\n",
    "                              end_date=self.watch_date,\n",
    "                              count=self.minute_count * self.N, frequency='30m',\n",
    "                              fields=['close', 'volume', 'open'],\n",
    "                              panel=False)\n",
    "\n",
    "    def _get_count(self):\n",
    "        \n",
    "        '''计算一日需要多少个周期'''\n",
    "        ALL_DAY = 240  # 一个完整交易日分钟数\n",
    "\n",
    "        if self.frequency[-1] != 'm':\n",
    "\n",
    "            raise ValueError('frequency参数必须是X minute(X必须是整数)')\n",
    "\n",
    "        self.minute_count = ALL_DAY / int(self.frequency.replace('m', ''))\n",
    "\n",
    "    def calc(self, beta: float) -> pd.Series:\n",
    "        \n",
    "        self.beta = round(beta,2)\n",
    "        # 文章貌似没说涨停股的处理...如果涨停对此因子的影响应该很大\n",
    "        data = (self.data.query('volume != 0')\n",
    "                         .pivot(index='time', columns='code'))\n",
    "\n",
    "        close_df = data['close']\n",
    "        vol_df = data['volume']\n",
    "        open_df = data['open']\n",
    "\n",
    "        ret_df = close_df / open_df - 1\n",
    "        abs_ret = ret_df.abs()\n",
    "        \n",
    "        if self.mod == 'normal':\n",
    "            \n",
    "            # St = |Rt|/√Vt，其中𝑅𝑡为第 t 分钟涨跌幅，𝑉𝑡为第 t 分钟成交量\n",
    "            S = abs_ret / vol_df.pow(beta)\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # 分钟涨跌幅绝对值除以分钟成交量对数值\n",
    "            S = abs_ret / np.log(vol_df)\n",
    "            \n",
    "        # 降序排列【从大到小排序】\n",
    "        S_rank = S.rank(ascending=False)\n",
    "\n",
    "        concat_df = pd.concat(\n",
    "            (S_rank.stack(), vol_df.stack(), close_df.stack()), axis=1, sort=True)\n",
    "        concat_df.columns = ['rank', 'vol', 'close']\n",
    "        \n",
    "        ser = concat_df.groupby(level='code').apply(self.calc_Q)\n",
    "        ser.name = self.name\n",
    "        return ser\n",
    "\n",
    "    # @staticmethod\n",
    "    def calc_Q(self, df: pd.DataFrame) -> float:\n",
    "\n",
    "        def vwap(df: pd.DataFrame) -> float:\n",
    "            \n",
    "            '''计算vwap'''\n",
    "            \n",
    "            try:\n",
    "                \n",
    "                v = np.average(df['close'], weights=df['vol'])\n",
    "                \n",
    "            except ZeroDivisionError:\n",
    "                \n",
    "                print(self.watch_date)\n",
    "                print(df)\n",
    "                print(sort_df['vol'])\n",
    "                raise ValueError('ZeroDivisionError')\n",
    "                \n",
    "            return v\n",
    "        \n",
    "        def _add_flag(sort_df: pd.DataFrame) -> pd.Series:\n",
    "            '''\n",
    "            标记将分钟数据按照指标St从大到小进行排序，\n",
    "            取成交量累积占比前20%的分钟\n",
    "            '''\n",
    "\n",
    "            cum_df = sort_df['vol'].cumsum() / sort_df['vol'].sum()\n",
    "\n",
    "            cond = (cum_df <= 0.2)\n",
    "\n",
    "            if (sort_df[cond].empty) and (cum_df.iloc[0] > 0.2):\n",
    "\n",
    "                return sort_df.iloc[:1, :]\n",
    "\n",
    "            return sort_df[cond]\n",
    "    \n",
    "        \n",
    "        # 将分钟数据按照指标St从大到小进行排序，取成交量累积占比前20%的分钟,视为聪明钱交易\n",
    "        sort_df = (df.reset_index()\n",
    "                     .set_index('rank')\n",
    "                     .sort_index())\n",
    "\n",
    "        smart_df = _add_flag(sort_df)\n",
    "        # 计算聪明钱交易的成交量加权平均价VWAPsmart\n",
    "        vwap_smart = vwap(smart_df)\n",
    "        # 计算所有交易的成交量加权平均价VWAPall\n",
    "        vwap_all_f = vwap(sort_df)\n",
    "\n",
    "        return vwap_smart / vwap_all_f\n",
    "    \n",
    "    @property\n",
    "    def name(self)->str:\n",
    "        \n",
    "        return f'Q_{self.N}_{self.frequency}_{self.beta}'\n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "# 因子参数构造\n",
    "def grid_factor(factor: Callable, lamb: Union[float, list]) -> pd.DataFrame:\n",
    "\n",
    "    if isinstance(lamb, (float, int)):\n",
    "        lamb = [lamb]\n",
    "\n",
    "    df_list = []\n",
    "    for l in lamb:\n",
    "\n",
    "        df_list.append(factor.calc(l))\n",
    "\n",
    "    return pd.concat(df_list, axis=1,sort=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "23656435e81643238cbacdbf4b1d1ab3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='因子计算', max=84, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 这个时间有点夸张 5h01m\n",
    "lamb = [-0.5,-0.25,-0.1,-0.05,0,0.05,0.1,0.25,0.33,0.5,0.7]\n",
    "factor_data = prepare_data('A','2014-01-01','2020-12-31','2021-01-31',\n",
    "                           Q_factor,{'func':grid_factor,'params':{'lamb':lamb}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据储存\n",
    "# factor_data.to_csv('smart_f.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们选取若干不同β值分别构造S指标，计算对应聪明钱因子，并对因子进行绩效回测。因子历史回测的基本框架为：回测时段为 2014年1月30日至2020年12月31日；样本空间为全体 A 股，剔除 ST 股和上市未满 60 日的新股；每月月末调仓，持仓一个自然月。\n",
    "\n",
    "从不同$\\beta$值的IC均值上看，当β为 0.7 时，因子IC均值在0左右，因子几乎无 效；随着$\\beta$值的逐渐减小，因子IC均值的绝对值逐渐增大，最后达到一个饱和的平台。可以看出，原始聪明钱因子（β=0.5）的选股能力，远远没有达到最优的状态。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算各β下的IC\n",
    "ic_df = factor_data.groupby(level='date').apply(src_ic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画图\n",
    "ic_df.mean().plot.bar(color='#4C72B0',title=r'不同$\\beta$下的IC均值');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了进一步评价因子的选股能力，我们回测了不同\\beta值下的聪明钱因子多空对冲信息比率和多空对冲净值曲线。可以看出，当$\\beta$由0.7逐渐减小时，信息比率逐渐增加，当β取值为-0.5左右时信息比率最大（0.08），当β由0.1继续逐渐减小时，信息比率呈现出缓慢下上升的趋势，但整体信息比率均高于0.06。可以看出，$\\beta$取值小于0.05以下的因子选股能力要明显优于原始聪明钱因子（β=0.5），并且当β取值为-0.5左右时，因子的选股能力最强。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取多空对冲收益\n",
    "excess_ret = get_excess_ret(factor_data,factor_data.columns[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "benchmark = get_price('000001.XSHG','2014-01-01','2020-12-31',fields='close')\n",
    "benchmark = benchmark.reindex(excess_ret.index)\n",
    "\n",
    "excess_ret['benchmark'] = benchmark['close'].pct_change()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fdad6bc1630>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "(risk_indicator_tear(excess_ret)['IR'].iloc[:-1]\n",
    "                    .plot\n",
    "                    .bar(color='#4C72B0',title=r'不同$\\beta$下的信息比率',figsize=(10,6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画图\n",
    "mpl.rcParams['font.family']='serif'\n",
    "\n",
    "fig,cum_axes = plt.subplots(1,2,figsize=(18,6))\n",
    "\n",
    "ep.cum_returns(excess_ret).plot(title=r'不同$\\beta$下多空累计收益',ax=cum_axes[0])\n",
    "excess_ret.mean().plot.bar(title='多空对冲分组平均收益',color='#4C72B0',ax=cum_axes[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "影响实盘的另一个因素是因子的换手率,我们着重对-0.5参数下各组合的换手率进行分析，可以看到各组的月换手特别高平均在80%左右。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取最优组合的换手率\n",
    "quantile_factor = factor_data.groupby(\n",
    "    level='date')['Q_10_30m_-0.5'].apply(lambda x: add_group(x))\n",
    "\n",
    "quantile_factor = quantile_factor.dropna()\n",
    "\n",
    "quantile_factor.index.names = ['date', 'asset']\n",
    "\n",
    "# 获取各组换手率\n",
    "quantile_turnover = pd.concat((perf.quantile_turnover(quantile_factor, q)\n",
    "                               for q in quantile_factor.sort_values().unique().tolist()), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1440 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画图\n",
    "quantile_turnover.plot(marker='o', ls='', subplots=True, figsize=(18, 4 * 5), sharex=False,\n",
    "                       title=[f'{g}组换手率' for g in quantile_factor.sort_values().unique().tolist()])\n",
    "plt.subplots_adjust(hspace=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**不同样本空间**\n",
    "\n",
    "\n",
    "沪深300中的因子表现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6800ad21aaed4debbcd99b0b59ae5816",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='因子计算', max=84, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# 5m13s\n",
    "hs300_1 = prepare_data('000300.XSHG','2014-01-01','2020-12-31','2021-01-31',\n",
    "                           Q_factor,{'func':grid_factor,'params':{'lamb':[-0.5]}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7de89291c7c840b68184a95f38075e64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='因子计算', max=84, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 4m44 对数化\n",
    "hs300_2 = prepare_data('000300.XSHG','2014-01-01','2020-12-31','2021-01-31',\n",
    "                           Q_factor,{'func':grid_factor,'params':{'lamb':[-0.5]}},mod='ln')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# 获取分组及计算IC\n",
    "\n",
    "hs300_1['group'] = hs300_1.groupby(\n",
    "    level='date')['Q_10_30m_-0.5'].transform(add_group)\n",
    "\n",
    "# 对数\n",
    "hs300_2['group'] = hs300_2.groupby(\n",
    "    level='date')['Q_10_30m_-0.5'].transform(add_group)\n",
    "\n",
    "\n",
    "# 计算IC\n",
    "hs300_ic_1 = hs300_1.groupby([pd.Grouper(level='date'), 'group'])[\n",
    "    ['Q_10_30m_-0.5', 'next_ret']].apply(src_ic)\n",
    "hs300_ic_1 = hs300_ic_1.unstack()['Q_10_30m_-0.5']\n",
    "\n",
    "# 对数\n",
    "hs300_ic_2 = hs300_2.groupby([pd.Grouper(level='date'), 'group'])[\n",
    "    ['Q_10_30m_-0.5', 'next_ret']].apply(src_ic)\n",
    "hs300_ic_2 = hs300_ic_2.unstack()['Q_10_30m_-0.5']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 分组IC均值图\n",
    "fig, ic_bar_axes = plt.subplots(1, 2, figsize=(15, 5))\n",
    "\n",
    "hs300_ic_1.mean().plot.bar(ax=ic_bar_axes[0], title='分组IC均值', color='#4C72B0')\n",
    "ic_bar_axes[0].axhline(0, color='black')\n",
    "hs300_ic_2.mean().plot.bar(\n",
    "    ax=ic_bar_axes[1], title='分组IC均值(对数)', color='#4C72B0')\n",
    "ic_bar_axes[1].axhline(0, color='black')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# 计算分组收益\n",
    "hs300_ret1 = get_algorithm_ret(hs300_1,'Q_10_30m_-0.5')\n",
    "hs300_cum1 = ep.cum_returns(hs300_ret1).add(1)\n",
    "\n",
    "hs300_ret2 = get_algorithm_ret(hs300_2,'Q_10_30m_-0.5')\n",
    "hs300_cum2 = ep.cum_returns(hs300_ret2).add(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x792 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画图\n",
    "fig,cum_axes = plt.subplots(2,figsize=(18,11))\n",
    "\n",
    "mpl.rcParams['font.family']='serif'\n",
    "hs300_cum1.plot(title='沪深300中分组净值情况',ax=cum_axes[0])\n",
    "\n",
    "hs300_cum2.plot(title='沪深300中分组净值情况(对数)',ax=cum_axes[1]);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "MarkDown菜单",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
